#include <iostream>
#include <vector>
#include <unordered_set>

using namespace std;

// const int MOD = 1e9 + 7;
// class Solution
// {
// public:
//     int countNum(int num)
//     {
//         int ret = 0;
//         while (num)
//         {
//             ret += num % 10;
//             num /= 10;
//         }
//         return ret;
//     }

//     void Print(vector<vector<int>> &vv)
//     {
//         for (auto &v : vv)
//         {
//             cout << '[';
//             for (auto &e : v)
//             {
//                 printf("%3d, ", e);
//             }
//             cout << "]\n";
//         }
//     }

//     int countLargestGroup1(int num)
//     {
//         vector<vector<int>> vv;
//         // vv.resize(37);
//         int max = 1;
//         for (int i = 1; i <= num; ++i)
//         {
//             int ret = countNum(i);
//             if (vv.size() <= ret)
//                 vv.resize(ret + 1);
//             vv[ret].push_back(i);
//         }
//         int n = 0;
//         for (auto &v : vv)
//         {
//             if (v.size() > n)
//             {
//                 n = v.size();
//                 max = 1;
//             }
//             else if (v.size() == n)
//                 ++max;
//         }
//         // Print(vv);
//         return max;
//     }

//     int countLargestGroup2(int num)
//     {
//         int arr[] = {
//             1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 
//             2, 3, 4, 5, 6, 7, 8, 9, 9, 1, 
//             2, 3, 4, 5, 6, 7, 8, 8, 8, 1, 
//             2, 3, 4, 5, 6, 7, 7, 7, 7, 1, 
//             2, 3, 4, 5, 6, 6, 6, 6, 6, 1, 
//             2, 3, 4, 5, 5, 5, 5, 5, 5, 1, 
//             2, 3, 4, 4, 4, 4, 4, 4, 4, 1, 
//             2, 3, 3, 3, 3, 3, 3, 3, 3, 1, 
//             2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 
//             1, 1, 1, 1, 1, 1, 1, 1, 1,};
//         if(num < 100) return arr[num - 1];

//         vector<vector<int>> vv;
//         vv.resize(3);
//         int xx9 = num;
//         int xx9_ = countNum(xx9);
//         while (xx9-- % 10 != 0)
//             ;

//         int max = 1;
//         for (int i = 1; i <= num; ++i)
//         {
//             int ret = countNum(i);
//             if(xx9_ - 1 == ret)
//                 vv[0].push_back(ret);
//             else if(ret == xx9_)
//                 vv[1].push_back(ret);
//             else if(ret == xx9_ + 1)
//                 vv[2].push_back(ret);
//         }
//         int n = 0;

//         if(vv[0].size() == vv[1].size())
//             ++max;
//         if(vv[2].size() == vv[1].size())
//             ++max;
//         // Print(vv);
//         return max;
//     }
// };

// #define NUM_BEGIN 1
// #define NUM_END 1000

// void test1()
// {

//     Solution sl;
//     for (int i = NUM_BEGIN; i < NUM_END; ++i)
//     {
//         cout << sl.countLargestGroup1(i) << ", ";
//         if (i % 10 == 0)
//             cout << endl;
//         // cout << "i = " << i << " 时, 算法1的结果 = ";
//         // cout << sl.countLargestGroup1(i) << endl;
//         // cout << "i = " << i << " 时, 算法2的结果 = ";
//         // cout << sl.countLargestGroup2(i) << endl;
//         // cout << "------------------------------------------------------------------------------------------\n";
//     }
// }
// void test2()
// {

//     Solution sl;
//     bool flag = true;
//     for (int i = NUM_BEGIN; i < NUM_END; ++i)
//     {
//         int ret1 = sl.countLargestGroup1(i);
//         int ret2 = sl.countLargestGroup2(i);
//         if (ret1 != ret2)
//         {
//             cout << "i = " << i << " 时, 算法1的结果 = " << ret1 << endl;
//             cout << "i = " << i << " 时, 算法2的结果 = " << ret2 << endl;
//             cout << "------------------------------------------------------------------------------------------\n";
//             flag = false;
//         }
//     }
//     if (flag)
//         cout << "代码优化成功! " << endl;
// }

class Solution {
    public:
        int find_min(vector<int>& nums, int unrep, int& left, int& right)
        {
            unordered_set<int> s;
            
            int n = nums.size();
            bool is_full = false;
            s.insert(nums[left]);
            while (!is_full && right < n) {
                ++right;
                s.insert(nums[right]);
                if (s.size() == unrep) {
                    is_full = true;
                    break;
                }
            }
            
            if(!is_full)
                return -1;
            else
            {
    
            s.clear();
            is_full = false;
            s.insert(nums[right]);
            int left = right;
            while (!is_full && left >= 0) {
                --left;
                s.insert(nums[left]);
                if (s.size() == unrep) {
                    is_full = true;
                    break;
                }
            }
    
            return right - left + 1;
    
            }
    
        }
    
        int countCompleteSubarrays(vector<int>& nums) {
            int n = nums.size();
            int ret = 0;
    
            unordered_set<int> s;
            for (const auto& e : nums) {
                s.insert(e);
            }
            int unrep = s.size();
    
            int left = 0;
            int right = 0;
            
    
            int min = find_min(nums,unrep, left, right);
            
            int tmp = find_min(nums, unrep, left, right);
            while(tmp != -1)
            {
                min = std::min(min, tmp);
                int tmp = find_min(nums, unrep, left, right);
            }
    
            return ret;
        }
    };

void test3()
{
    Solution sl;
    vector<int> v1 = {1,3,1,2,2};
    sl.countCompleteSubarrays(v1);
}

int main()
{
    // test1();
    // test2();
    test3();
    return 0;
}
